home *** CD-ROM | disk | FTP | other *** search
/ Celestin Apprentice 5 / Apprentice-Release5.iso / Source Code / Libraries / DCLAP 6d / dclap6d / DNet / DGoDoc.cpp < prev    next >
Text File  |  1996-07-05  |  61KB  |  2,276 lines
  1. // DGopherDoc.cp
  2. // d.g.gilbert
  3.  
  4.  
  5.  
  6.  
  7. #include "DGoDoc.h"
  8. #include "DGoNetDoc.h"
  9.  
  10. #include "DGoAskDoc.h"
  11. #include "DGoPrefs.h"
  12.  
  13. #include <ncbi.h>
  14. #include <dgg.h>
  15. #include <Dvibrant.h>
  16. #include <DApplication.h>
  17. #include <DGopher.h>
  18. #include <DGoList.h>
  19. #include <DGoInit.h>
  20. #include <DGoPlus.h>
  21. #include <DGoClasses.h>
  22. #include <DPanel.h>
  23. #include <DControl.h>
  24. #include <DDialogText.h>
  25. #include <DWindow.h>
  26. #include <DMenu.h>
  27. #include <DFile.h>
  28. #include <DUtil.h>
  29. #include <DIconLib.h> //??
  30. #include <DIcons.h>
  31.  
  32.  
  33. enum ResizeWindSizes {
  34.     kWinDragHeight = 20,
  35.     kWinScrollWidth = 0,   // added to both vert & hor.
  36.     kWinMinWidth = 0,
  37.     kWinExtraHeight= 0
  38.     };
  39.  
  40. /* from vibrant/vibwndws.c */
  41. extern "C" void Nlm_ResizeWindow(Nlm_GraphiC w, Nlm_Int2 dragHeight,
  42.                               Nlm_Int2 scrollWidth, Nlm_Int2 minWidth,
  43.                               Nlm_Int2 extraHeight);
  44. /* for doc window: Nlm_ResizeWindow (w, 20, 0, Nlm_StringWidth (title) + 70, 0); */
  45.  
  46.  
  47. Global  Nlm_RecT  gGopherListDocRect = { 0, 0, 0, 0 };
  48. Global  DGopherListDoc* gGopherDoc = NULL;
  49.  
  50. enum { kGolistViewWidth = 225 };
  51.  
  52. enum DGoDocCmds {
  53.     cProcessGopher = 30346,
  54.     cStuf,
  55.     cStufInline,
  56.     cSave,
  57.     cAdd,
  58.     cProcessInlines
  59.     };
  60.  
  61. char* DGopherListDoc::kGopherDocSuffix = ".go4";
  62.  
  63. Local Nlm_FonT    gSmallFont= NULL;
  64.  
  65. inline void MakeSmallFont()
  66. {
  67.     if (!gSmallFont) 
  68.         gSmallFont = Nlm_GetFont( "Times", 9, false, false, false, "Roman");
  69. }
  70.  
  71.  
  72.  
  73.  
  74.  
  75.  
  76.  
  77.  
  78.  
  79. class DGoDropMenuButton : public DIconButton
  80. {
  81. public:
  82.     DPopupList* fPop;
  83.     
  84.      DGoDropMenuButton(long id, DView* itsSuperior, DIcon* itsIcon, DPopupList* itsPopup);
  85.     virtual void Click(Nlm_PoinT mouse);
  86.     virtual void Release(Nlm_PoinT mouse);
  87.  
  88. };
  89.  
  90. DGoDropMenuButton::DGoDropMenuButton(long id, DView* itsSuperior, 
  91.                                                         DIcon* itsIcon, DPopupList* itsPopup):
  92.         DIconButton( id, itsSuperior, itsIcon),
  93.         fPop(itsPopup)
  94. {
  95. }
  96.  
  97. void DGoDropMenuButton::Click(Nlm_PoinT mouse)
  98. {
  99.     DIconButton::Click(mouse);
  100.     fPop->Show();
  101.     fPop->Invalidate();
  102.     //Nlm_Beep();
  103. }
  104.  
  105. void DGoDropMenuButton::Release(Nlm_PoinT mouse)
  106. {
  107.     fPop->Hide();
  108.     fPop->Invalidate();
  109.     DIconButton::Release(mouse);
  110. #if 0
  111.     Nlm_RecT area;
  112.     this->ViewRect( area);
  113.     if (fFrame) Nlm_InsetRect( &area, kFInset, kFInset);
  114.     Nlm_InvertRect( &area);
  115.     if (Nlm_PtInRect( mouse, &area)) {
  116.         // then button is "selected", otherwise not.
  117.         this->IsMyViewAction(this);
  118.         }
  119. #endif
  120. }
  121.  
  122.  
  123.  
  124.  
  125. //class    DGopherListDoc : public DWindow
  126.  
  127. Boolean DGopherListDoc::gOptionIsOn = false;
  128. Boolean DGopherListDoc::gFetchSingles = true;
  129. DMenu * DGopherListDoc::gViewChoiceMenu = NULL;
  130. DView * DGopherListDoc::gLockWinMenuItem = NULL;
  131.  
  132. Local DGopherList *     gClipGophers = NULL;
  133. Local DGopher       *     gClipGopher = NULL;
  134.  
  135.  
  136. DGopherListDoc::DGopherListDoc( long id) :
  137.         DWindow( id, gApplication) 
  138. {
  139.     Initialize(NULL);
  140.     //fParentlist= new DList(NULL, DList::kDeleteObjects);
  141.     fParentlist= new DList(NULL);
  142.     SetInfoLine();
  143. }
  144.  
  145.  
  146. DGopherListDoc::DGopherListDoc( long id, DGopher* parentGopher) :
  147.         DWindow( id, gApplication)
  148. { 
  149.     Initialize(NULL);
  150.     fParent= parentGopher;
  151.     if (fParent) fParent->newOwner();
  152.     //fParentlist= new DList(NULL, DList::kDeleteObjects);
  153.     fParentlist= new DList(NULL);
  154.     SetInfoLine();
  155. }
  156.  
  157. DGopherListDoc::DGopherListDoc( long id, DGopherList* activeList, char* name) :
  158.         DWindow( id, gApplication) 
  159. { 
  160.     Initialize(name);
  161.  
  162.     //fGolist= activeList;
  163.     // !! clone fGolist !?
  164.     //if (fGolist) fParent= fGolist->fParentMenu;
  165.     //if (fParent) fParent->newOwner();
  166.     //fParentlist= new DList(NULL, DList::kDeleteObjects);
  167.     fParentlist= new DList(NULL);
  168.  
  169.     SetInfoLine();
  170.     this->ReplaceData( activeList); //??
  171. }
  172.  
  173.  
  174. DGopherListDoc::~DGopherListDoc()
  175. {
  176.     if (fGolist) {
  177.         //if (fGolist->GetOwnerCount() <= 1) delete fGolist; else 
  178.         fGolist->suicide();  
  179.         }
  180.     if (fOldlist) {
  181.         //if (fOldlist->GetOwnerCount() <= 1) delete fOldlist; else 
  182.         fOldlist->suicide();  
  183.         }
  184.     if (fParentlist) {
  185.         short i, n= fParentlist->GetSize();
  186.         for (i=0; i<n; i++) {
  187.             short j, m;
  188.             DGopherList* st= (DGopherList*) fParentlist->At(i);
  189.             delete st;
  190.             }
  191.         delete fParentlist;
  192.         }
  193. #if 0
  194.     //if (fParentPop) delete fParentPop;  //noooooooooo ... dview::deletesubviews...
  195.     //if (fGoview) fGoview->suicide();  //noooooooooo ... dview::deletesubviews...
  196.     //if (fParent) fParent->suicide();  // !BOMB BUG -- fParent sometimes (?) in fGolist
  197. #endif
  198. }
  199.  
  200.  
  201. void DGopherListDoc::Initialize( char* name)
  202. {
  203.     fGoview= NULL;
  204.     fGolist= NULL; 
  205.     fOldlist= NULL;
  206.     fStatus= NULL;
  207.     fParentlist= NULL;
  208.     fParent= NULL;
  209.     fInUse= false;
  210.     fPinned= false;
  211.     fFirststuff= 1;
  212.     fParentPop= NULL;
  213.     fStickpin= NULL;
  214.     
  215.     short width= -1, height= -1, left= -10, top= -20; // default window loc
  216.     if (!Nlm_EmptyRect(&gGopherListDocRect))  {
  217. #ifndef TRY_WIN_MOTIF
  218.             // leave out of motif til find bug preventing its' DView::SizeTo...
  219.         width= MAX( 40, gGopherListDocRect.right - gGopherListDocRect.left);
  220.         height= MAX( 50, gGopherListDocRect.bottom - gGopherListDocRect.top);
  221. #endif
  222.         }
  223.     this->InitWindow(document, width, height, left, top, name); 
  224. }
  225.  
  226.  
  227.  
  228. void DGopherListDoc::SetInfoLine()
  229. {
  230.     DPrompt* pr;
  231.     Nlm_PoinT nps, droppt;
  232.     Nlm_FonT smallfnt = Nlm_GetFont( "Times", 9, false, false, false, "Roman");
  233.     //smallfnt= Nlm_programFont;
  234.  
  235.     nps.x= 1;
  236.     nps.y= 1; // clear some weird offset on new docs !? 
  237.     this->SetNextPosition( nps);
  238.     fStickpin= new DIconButton( cPushpin, this, &gPushpinOut);
  239.     this->NextSubviewToRight();
  240.  
  241. #if 0
  242.     this->GetNextPosition( &nps);
  243.     fParentPop= new DPopupList( cParentPopup, this);
  244.     fParentPop->Hide();
  245.     nps.x += 5;  
  246.     this->SetNextPosition( nps);
  247.     DGoDropMenuButton* ib = 
  248.         new DGoDropMenuButton( cParentDrop, this, &gDownTriangle, fParentPop);
  249.     this->NextSubviewToRight();
  250. #endif
  251.  
  252. #if 0
  253.     DIconButton* ib = new DIconButton( cParentDrop, this, &gDownTriangle);
  254.     this->NextSubviewToRight();
  255.     pr= new DPrompt( 0, this, "Recent:", 0, 0, smallfnt);             
  256.     //pr->SetResize( DView::fixed, DView::moveinsuper);
  257.     this->NextSubviewToRight();
  258.  
  259.     fParentPop= new DPopupList( cParentPopup, this);
  260.     //fParentPop->SetResize( DView::fixed, DView::moveinsuper);  
  261.     this->NextSubviewToRight();
  262.     this->GetNextPosition( &nps);
  263.     nps.x += 50; // 150 
  264.     this->SetNextPosition(nps);
  265. #endif
  266.  
  267.     pr= new DPrompt( 0, this, "Status:", 0, 0, smallfnt); 
  268.     //pr->SetResize( DView::fixed, DView::fixed);
  269.     this->NextSubviewToRight();
  270.  
  271.     fStatus= new DPrompt(  0, this, NULL, 150, 0, smallfnt);   // 350
  272.     //fStatus->SetResize( DView::fixed, DView::fixed);
  273.     this->NextSubviewBelowLeft();
  274.     if (fParent) fParent->fStatusLine= fStatus;
  275. }
  276.  
  277.  
  278. void DGopherListDoc::EmptyData(Boolean saveit)
  279. {
  280.     if (saveit)  
  281.         fParentlist->Push( fGolist);
  282.     else {
  283.         if (fOldlist) fOldlist->suicide(); //delete fOldlist;  
  284.         fOldlist= fGolist;
  285.         if (fParent) fParent->suicide();  
  286.         }
  287.     fGolist= NULL;
  288.     fParent= NULL;
  289.     //if (fGoview) fGoview->suicide();  //noooooooooo ... dview::deletesubviews...
  290.     if (fParentPop) {
  291.             //  doesn't vibrant know how to clean out a (popup)menu list !?
  292.         fParentPop->Reset(); // does this drop menu items ?? YES
  293.         //delete fParentPop;
  294.         //fParentPop= new DPopupList( cParentPopup, this);
  295.         }
  296.     if (fGoview) fGoview->SetEmptySelection(false);
  297.     fFirststuff= 1;
  298.     fInUse= false;
  299. }
  300.  
  301.  
  302. Boolean DGopherListDoc::ReplaceData( DGopher* parentGopher, char* name, DFile* aFile)
  303. {
  304.     if (!fInUse && !fPinned) {
  305.         Boolean ok = false;
  306.         if (parentGopher) ok= this->CanReadFrom( parentGopher);
  307.         else ok= this->CanReadFrom( aFile);
  308.         if (ok) {
  309.              EmptyData(true);    
  310.             if (name) this->SetTitle( name); 
  311.             if (parentGopher) {
  312.                 parentGopher->newOwner(); // DGopherListDoc constructor normally does this...
  313.                 this->Open( parentGopher);
  314.                 }
  315.             else this->Open( aFile);
  316.             return true;
  317.             }
  318.         return true; // !!!!!??? this is a funny result when we didn't replace !! but
  319.                 // it means don't try a new window !!
  320.         }
  321.     return false;
  322. }
  323.  
  324.  
  325. Boolean DGopherListDoc::ReplaceData( DGopherList* parentlist)
  326. {
  327.         // ! this is buggy still for real replace, but is also used for new DGoListDoc !
  328.     if (!fInUse && !fPinned && parentlist) {
  329.         EmptyData(false);
  330.         fGolist= parentlist;
  331.         fParent= fGolist->fParentMenu;
  332.         if (!fGoview) {
  333.             MakeSubviews(); //fGoview= new DGolistView(0, this, fGolist, kGolistViewWidth);
  334.             fGoview->ChangeRowSize( -1, fGolist->GetSize());  
  335.             }
  336.          else {
  337.              fGoview->fItems= fGolist;
  338.             short nold= fGoview->GetMaxRows();
  339.             short nnew= fGolist->GetSize();
  340.             fGoview->ChangeRowSize( -1, nnew-nold);  
  341.             }
  342.         fGoview->SetColWidths();     //!
  343.         this->Open(true);  
  344.         return true;
  345.         }
  346.     else
  347.         return false;
  348. }
  349.  
  350. Boolean DGopherListDoc::PopData( short numitems)
  351. {
  352.         // this freezes after first !!
  353.     short npop= MIN( numitems, fParentlist->GetSize());
  354.     if (!fInUse && !fPinned && npop) {
  355.     
  356.         EmptyData(false);
  357.         
  358.         for ( ; npop>0; npop--) {
  359.             if (fGolist) fGolist->suicide(); //delete fGolist;  
  360.             fGolist= (DGopherList*) fParentlist->Pop();
  361.             }
  362.  
  363.         if (!fGoview) {
  364.             MakeSubviews(); //fGoview= new DGolistView(0, this, fGolist, kGolistViewWidth);
  365.             fGoview->ChangeRowSize( -1, fGolist->GetSize());  
  366.             }
  367.          else {
  368.              fGoview->fItems= fGolist;
  369.             short nold= fGoview->GetMaxRows();
  370.             short nnew= fGolist->GetSize();
  371.             fGoview->ChangeRowSize( -1, nnew-nold);  
  372.             }
  373.         fGoview->SetColWidths();     //!
  374.                         
  375.         fParent= fGolist->fParentMenu;
  376.         this->Open(true);
  377.         return true;
  378.         }
  379.     else
  380.         return false;
  381. }
  382.  
  383.  
  384. Boolean DGopherListDoc::IsGopherDoc(DFile* aFile)
  385. {
  386.     // test to see if aFile is a gopher doc.
  387.     // this is a static function, usable w/o a DGopherListDoc object
  388.     
  389.     if (aFile && aFile->Exists()) {
  390.         char    line[256];
  391.         aFile->OpenFile();
  392.         aFile->ReadLine( line, 256);
  393.         return DGopherList::IsGopherLine( line);
  394.         }
  395.     else
  396.         return false;
  397. }
  398.  
  399.  
  400. void DGopherListDoc::SortView(DGopherList::Sorts sortorder)
  401. {
  402.     fGolist->SortList(sortorder);
  403.     fGoview->Invalidate();
  404. }
  405.  
  406. void DGopherListDoc::ToTextDoc( Boolean ViewAsLink)
  407. {
  408.     Nlm_ParData paratabs = {false, false, false, false, true, 0, 0}; // tabs==tabs
  409.   Nlm_ParData parafmt  = {false, false, false, false, false, 0, 0}; // tabs==colFmt
  410.     char    *txt     = NULL;
  411.     Nlm_ColData*    cols= NULL;
  412.     Nlm_ParData*    para= ¶tabs;
  413.  
  414.           // this colFmt needs work -- ?? use char sizes rather than pixel sizes ??
  415. #if 0  
  416. // DAMN SUN CC/CFRONT FAILS at THIS !? the bozo 
  417.     Nlm_ColData colFmt [8] = {
  418.       { 0, 0, 40, 1, gTextFont, 'l', FALSE, FALSE, FALSE, FALSE}, // name
  419.       { 0, 0,  7, 1, gTextFont, 'l', FALSE, FALSE, FALSE, FALSE},    // date
  420.       { 0, 0,  6, 1, gTextFont, 'l', FALSE, FALSE, FALSE, FALSE},    // size
  421.       { 0, 0, 10, 1, gTextFont, 'l', FALSE, FALSE, FALSE, FALSE},    // kind
  422.       { 0, 0, 25, 1, gTextFont, 'l', FALSE, FALSE, FALSE, FALSE},    // path
  423.       { 0, 0, 25, 1, gTextFont, 'l', FALSE, FALSE, FALSE, FALSE},    // host
  424.       { 0, 0,  5, 1, gTextFont, 'r', FALSE, FALSE, FALSE, FALSE},    // port
  425.       { 0, 0, 30, 1, gTextFont, 'l', FALSE, FALSE, FALSE, TRUE}        // admin
  426.         };
  427. #else
  428. // for damn sun CC cfront
  429.         Nlm_ColData colFmt [8];
  430.        Nlm_ColData colFmt0 ={ 0, 0, 40, 1, NULL, 'l', FALSE, FALSE, FALSE, FALSE, FALSE}; // name
  431.        Nlm_ColData colFmt1 ={ 0, 0,  7, 1, NULL, 'l', FALSE, FALSE, FALSE, FALSE, FALSE};    // date
  432.        Nlm_ColData colFmt2 ={ 0, 0,  6, 1, NULL, 'l', FALSE, FALSE, FALSE, FALSE, FALSE};    // size
  433.        Nlm_ColData colFmt3 ={ 0, 0, 10, 1, NULL, 'l', FALSE, FALSE, FALSE, FALSE, FALSE};    // kind
  434.        Nlm_ColData colFmt4 ={ 0, 0, 25, 1, NULL, 'l', FALSE, FALSE, FALSE, FALSE, FALSE};    // path
  435.        Nlm_ColData colFmt5 ={ 0, 0, 25, 1, NULL, 'l', FALSE, FALSE, FALSE, FALSE, FALSE};    // host
  436.        Nlm_ColData colFmt6 ={ 0, 0,  5, 1, NULL, 'r', FALSE, FALSE, FALSE, FALSE, FALSE};    // port
  437.        Nlm_ColData colFmt7 ={ 0, 0, 30, 1, NULL, 'l', FALSE, FALSE, FALSE, FALSE, TRUE};        // admin
  438.     colFmt[0]= colFmt0;
  439.         colFmt[1]= colFmt1;
  440.         colFmt[2]= colFmt2;
  441.         colFmt[3]= colFmt3;
  442.         colFmt[4]= colFmt3;
  443.         colFmt[5]= colFmt5;
  444.         colFmt[6]= colFmt6;
  445.         colFmt[7]= colFmt7;
  446. #endif
  447.     
  448.     if (ViewAsLink)
  449.         txt= fGolist->WriteLinksForServer();
  450.     else {
  451.             //! later -- set these from user display prefs ....
  452.         Boolean showdate= true, showsize= true, showkind= true, showpath= false,
  453.                 showhost=true, showport=true, showadmin= true;
  454.         txt= fGolist->WriteLinksForDisplay( showdate, showsize, showkind, showpath,
  455.                         showhost, showport, showadmin);
  456.                         
  457.             // this col formatting isn't working right -- name col is too short
  458.         //cols= colFmt;
  459.         //para= ¶fmt;
  460.         }
  461.         
  462.     if (txt) {
  463.         // ?? add fancy col tabs ForDisplay ??
  464.         char name[256];
  465.         strcpy(name,"Text of ");
  466.         long len= strlen(name);
  467.         char *namep= name+ len;
  468.         len = 256 - len;
  469.         (void) this->GetTitle(namep, len);
  470.         DWindow* aWin= new DWindow( 0, gApplication, document, -1, -1, -10, -10, name);
  471.         DTextDocPanel* aDoc= new DTextDocPanel( 0, aWin, 500, 300);
  472.         aDoc->SetResize( DView::matchsuper, DView::relsuper);
  473.         //aDoc->SetSlateBorder( false);
  474.         aDoc->SetTabs( gTextTabStops);
  475.         aDoc->Append( txt, para, cols, gTextFont);
  476.         aWin->Open();  
  477.         aDoc->SizeToSuperview( aWin, true, false);
  478.         }
  479. }
  480.  
  481.  
  482. void DGopherListDoc::ShowMessage(const char* msg)
  483. {
  484.     if (fStatus) fStatus->SetTitle( (char*)msg);
  485. }
  486.  
  487.  
  488. // static
  489. void DGopherListDoc::ProcessFile( DFile* aFile)
  490. {
  491.     Boolean replaced= false;
  492.     //if (gGopherDoc) // !??? this is bad, set to non-null when must be null, on 68Kmac
  493.     //    replaced= gGopherDoc->ReplaceData( NULL, NULL, aFile);
  494.     if (! replaced ) {
  495.         DGopherListDoc* adoc= new DGopherListDoc( kGoListdoc);
  496.         adoc->Open(aFile);   
  497.         }
  498. }
  499.  
  500.  
  501.  
  502. // static
  503. Boolean DGopherListDoc::ProcessGopherWithTest( DGopher* theGo)
  504. {
  505.     DWindow* win;
  506.     
  507.         // ?? always reset thread state here ??
  508.     theGo->fThreadState= DGopher::kThreadNotStarted;  
  509.     if (theGo->fThreadState == DGopher::kThreadNotStarted) {
  510.         if (theGo->fHasAsk && theGo->fHaveReply) theGo->fQueryPlus= theGo->fReplyData;  
  511.         theGo->OpenQuery();
  512.         }
  513.     //fInUse= true; //??
  514.     
  515.     if (theGo->fThreadState == DGopher::kThreadDoneReading) { 
  516.         theGo->fThreadState= DGopher::kThreadNotStarted; // ! need to reset this somewhere for used gophers
  517.         return false; 
  518.         }
  519.     else {
  520.         DTask* readTask= theGo->newTask(cRead, DGopher::kGopherTask);
  521.         readTask->SetRepeat(true);
  522.         theGo->fTransferType= kTransferBinary;  // ! NOT True always, but need in cases of binary data? ?!
  523.         theGo->ProcessTask(readTask); // read 1st part of data
  524.         theGo->PostTask( readTask);        // post to event handler to read rest of data
  525.         
  526.         char * cbeg = theGo->fInfo;
  527.         ulong clen = theGo->fInfoSize;
  528.         char * datastart;
  529.         short format= DGoLinkedTextDoc::TestFormat(cbeg, clen, datastart);
  530.         switch (format) {
  531.         
  532.             case DGopher::cGopherNetDoc:
  533.                 DGopherListDoc::NewNetdoc( theGo, readTask);
  534.                 break;
  535.  
  536.             case DGopher::cNewGopherFolder:
  537.             case DGopher::cOpenGopherFolder:
  538.                 if (true) { // (! this->ReplaceData( theGo, NULL, NULL)) {
  539.                     DGopherListDoc* win= new DGopherListDoc( DGopherListDoc::kGoListdoc, theGo);
  540.                     win->Open( theGo);  
  541.                     }
  542.                 break;
  543.         
  544.             case DGopher::cNewGopherFile:
  545.             case DGopher::cOpenGopherFile:
  546.             caseFile:
  547.                 win= new DGopherFileDoc( DGopherFileDoc::kGoFiledoc, theGo);  
  548.                 win->Open();
  549.                 break;
  550.     
  551. #if 0
  552.             case DHTMLHandler::kHTMLformat: 
  553.             case DGIFHandler::kGIFformat    : 
  554.             case DPICTHandler::kPICTformat:  
  555.             case DRTFHandler::kRTFformat  : 
  556. #endif
  557.             default:
  558.                 if (theGo->fSaveToDisk) goto caseFile;
  559.                 if (gGopherTextDoc && gGopherTextDoc->PushNewDoc(theGo, NULL)) 
  560.                     ;
  561.                 else {
  562.                     win= new DGoLinkedTextDoc( DGoLinkedTextDoc::kGoLitextdoc, theGo, NULL); //?? this);  
  563.                     win->Open();
  564.                     }
  565.                 break;
  566.  
  567.                 }
  568.             return true;
  569.             }
  570. }
  571.  
  572.  
  573.  
  574. // static
  575. void DGopherListDoc::NewNetdoc( DGopher* theGo, DTask* readTask)
  576. {
  577.     DWindow* win;
  578.     Boolean  doPostReader = false;
  579.     
  580.     // document is gopher link data followed by any other document data kind
  581. #if 1
  582.     DGopherList* newGolist= new DGopherList(NULL);
  583. #else
  584.     DGopherListDoc* newGopherDoc= new DGopherListDoc();
  585.     newGopherDoc->fGolist= new DGopherList(NULL);
  586.     newGopherDoc->fGoview= new DGolistView(0, newGopherDoc, newGopherDoc->fGolist, kGolistViewWidth);
  587. #endif
  588.  
  589.     // read data from net & process as gopherdoc data as long as it
  590.     // is right kind: +INFO: ... +etc:
  591.     // ?? look for transition flag, +DATA: ??
  592.     if (theGo->fThreadState == DGopher::kThreadNotStarted) {
  593.         if (theGo->fHasAsk && theGo->fHaveReply) theGo->fQueryPlus= theGo->fReplyData;  
  594.         theGo->OpenQuery();
  595.         }
  596.     theGo->fTransferType= kTransferBinary; // !?! this is a problem !! need to resolve
  597.  
  598.     if (theGo->fInfoSize<10 && theGo->fThreadState == DGopher::kThreadDoneReading) { 
  599.         theGo->fThreadState= DGopher::kThreadNotStarted; // ! need to reset this somewhere for used gophers
  600.         return; 
  601.         }
  602.     else {
  603.         char * cbeg, * cdata, * cp, * ep;
  604.         ulong clen;
  605.         Nlm_Uint4 ioffs;
  606.         Boolean found= false;
  607.         ioffs= 0;
  608.         cdata= NULL;
  609.         if (readTask) {
  610.             doPostReader= false;
  611.             }
  612.         else {
  613.             readTask= theGo->newTask(cRead, DGopher::kGopherTask);
  614.             readTask->SetRepeat(true);
  615.             doPostReader= true;
  616.             }
  617.         do {
  618.             theGo->ProcessTask(readTask); // read 1st part of data
  619.             cbeg = theGo->fInfo;
  620.             clen = theGo->fInfoSize;
  621.             cp= cbeg + ioffs;
  622.             found= false;
  623.             do {
  624.               ep= (char*) MemChr( cp, kLF, clen - ioffs);
  625.               if (!ep) ep= (char*) MemChr( cp, kCR, clen - ioffs);
  626.               if (ep) {
  627.                   cp = ep+1;
  628.                   if (*cp == '+') found = (StrNICmp( cp, "+DATA:", 6) == 0);
  629.                   }
  630.               ioffs= cp - cbeg;
  631.             } while (!found && ep);
  632.             if (found) cdata= cp;
  633.         } while (!found && theGo->fThreadState != DGopher::kThreadDoneReading);
  634.             
  635.          if (found) {
  636.              
  637.              {  // drop the +MENU: indent !
  638.              char *cp, *newp, thisc, lastc;
  639.              ioffs= 0;
  640.             found= Nlm_StrngPos(cbeg, "+MENU:"/*CRLF*/,0, false/*case*/, &ioffs);
  641.             if (found) {
  642.                 cbeg += ioffs + 6; 
  643.                 for (cp= newp= cbeg, lastc= 0; cp < cdata && *cp; cp++) {
  644.                     thisc= *cp;
  645.                     if (!(thisc == ' ' && (lastc == kCR || lastc == kLF))) 
  646.                         *newp++= thisc;
  647.                     lastc= thisc;
  648.                     }
  649.                 *newp= 0;
  650.                 }
  651.             }
  652.             
  653.           //newGopherDoc->AddData( cbeg, cdata-cbeg); //ReadLinks
  654.           newGolist->ReadLinks(  cbeg, cdata-cbeg);
  655.           cdata += 6; // ?? + sizeof("+DATA:"/*CRLF*/);
  656.           while (*cdata == '+' || isspace(*cdata)) cdata++;
  657.             // look for gopher size info
  658.             if (*cdata == '-' || isdigit(*cdata)) {
  659.                 theGo->fBytesExpected = atol( cdata);
  660.               while (*cdata == '-' || isdigit(*cdata)) cdata++;
  661.             if (*cdata == kCR || *cdata == kLF ) cdata++;
  662.             if (*cdata == kCR || *cdata == kLF ) cdata++;
  663.                 }
  664.             theGo->fInfoSize -= (cdata - theGo->fInfo);
  665.             Nlm_MemMove( theGo->fInfo, cdata, theGo->fInfoSize+1); 
  666.             }
  667.             
  668.         //if (theGo->fInfoSize < 1024) 
  669.         if (theGo->fThreadState != DGopher::kThreadDoneReading)
  670.             theGo->ProcessTask(readTask); // read more of data so testor can find format
  671.         if (doPostReader) theGo->PostTask(readTask);        // post to event handler to read rest of data
  672.         if (gGopherTextDoc && gGopherTextDoc->PushNewDoc(theGo, newGolist)) 
  673.             ;
  674.         else {
  675.             win= new DGoLinkedTextDoc( DGoLinkedTextDoc::kGoLitextdoc, theGo, newGolist); //?? this);  
  676.             win->Open();
  677.             }
  678.         //newGopherDoc->suicide(); //!? DGoLinkedTextDoc is now owner
  679.         newGolist->suicide(); 
  680.         }
  681. }
  682.  
  683.  
  684. //static
  685. void DGopherListDoc::ProcessGopher( DGopher* theGo, short itsViewChoice)
  686. {
  687.     DWindow* win;
  688.     
  689.     if (theGo) {
  690.         gCursor->watch();
  691.  
  692.         switch (theGo->ItemForm(itsViewChoice)) {   
  693.  
  694. #if 1
  695.             case DGopher::cOpenGopherText:
  696.             case DGopher::cNewGopherText:
  697.             case DGopher::cNewGopherFolder:
  698.             case DGopher::cOpenGopherFolder:
  699.             caseText:
  700.                 (void) DGopherListDoc::ProcessGopherWithTest( theGo);                
  701.                 break;
  702. #else
  703.             case DGopher::cOpenGopherText:
  704.             case DGopher::cNewGopherText:
  705.             caseText:
  706.                 if (theGo->fSaveToDisk) goto caseFile;
  707.                 if (gGopherTextDoc && gGopherTextDoc->PushNewDoc(theGo, NULL)) 
  708.                     ;
  709.                 else
  710.                     win= new DGoLinkedTextDoc( DGoLinkedTextDoc::kGoLitextdoc, theGo, NULL); //?? this);  
  711.                     win->Open();
  712.                     }
  713.                 break;
  714.  
  715.             case DGopher::cNewGopherFolder:
  716.             case DGopher::cOpenGopherFolder:
  717.                 if (! this->ReplaceData( theGo, NULL, NULL)) {
  718.                     DGopherListDoc* win=
  719.                         new DGopherListDoc( DGopherListDoc::kGoListdoc, theGo);
  720.                     win->Open( theGo);  
  721.                     }
  722.                 break;
  723. #endif    
  724.  
  725.             case DGopher::cGopherNetDoc:
  726.                 DGopherListDoc::NewNetdoc( theGo, NULL);
  727.                 break;
  728.  
  729.             case DGopher::cNewGopherImage:
  730.             case DGopher::cOpenGopherImage:
  731.                 {
  732.                 DGopherMap* aMapper= NULL;
  733.                 if (gGopherMap) aMapper = gGopherMap->MatchHandlerKind( theGo);
  734.                 if (aMapper && aMapper->GetDisplay() ) goto caseText;
  735.                 else goto caseFile;
  736.                 }
  737.                 break;
  738.                                 
  739.             case DGopher::cNewGopherFile:
  740.             case DGopher::cOpenGopherFile:
  741.             caseFile:
  742.                 win= new DGopherFileDoc( DGopherFileDoc::kGoFiledoc, theGo); //'GFil'
  743.                 win->Open();
  744.                 break;
  745.         
  746.             case DGopher::kGopherTask:
  747.                 if (theGo->fHasAsk && theGo->fHaveReply) theGo->fQueryPlus= theGo->fReplyData;  
  748.                 theGo->OpenQuery();
  749.                 break;
  750.  
  751.             case DGopher::cGopherGetInfo:
  752.                 win= new DGopherInfoDoc( DGopherInfoDoc::kGoInfodoc, theGo); // 'GIfo'
  753.                 win->Open();
  754.                 break;
  755.             
  756.             case DGopher::cNewGopherAsk:
  757.             case DGopher::cOpenGopherAsk:
  758.                 win= 
  759.                     new DGopherAskDoc( DGopherAskDoc::kGoAskdoc, theGo, gGopherDoc/*this*/, itsViewChoice);
  760.                 if (win) win->Open();
  761.                 break;
  762.     
  763.             default:
  764.                 break;
  765.             }
  766.         
  767.         gCursor->arrow();
  768.         }
  769. }
  770.  
  771.  
  772. // static
  773. void DGopherListDoc::ReadItemInfo(DGopher* theGo)
  774. {
  775.     if (theGo) {
  776.         gCursor->watch();
  777.         short aSavedType= theGo->fTransferType;
  778.         theGo->fTransferType= kTransferText;
  779.         theGo->InfoTask();   
  780.         theGo->ShowMessage("read item info...");
  781.         while (theGo->ThreadProgress() != DGopher::kThreadDoneReading) {
  782.             gApplication->ProcessTasks();  // wait for info to arrive
  783.             }
  784.         theGo->CloseQuery(); // patch for mswin net bug ?? 
  785.         theGo->DeleteInfo(); 
  786.         theGo->ShowMessage(" ");
  787.         theGo->fTransferType= aSavedType;
  788.         gCursor->arrow();
  789.         }
  790. }
  791.  
  792. void DGopherListDoc::TopOfGopherHole()
  793. {    
  794.     DGopher* aGopher= fGoview->SelectedGopher();
  795.     short aRow = fGoview->GetSelectedRow();
  796.     if (aGopher) {
  797.         DGopher* bGopher= DGopherList::CopyToNewKind( kTypeFolder, aGopher, fGolist);
  798.         if (bGopher) {
  799.             bGopher->StorePath("");         // this is key to top of gopher server
  800.             char buf[256];
  801.             StrCpy(buf, "Gopher at ");
  802.             StrNCat(buf, bGopher->GetHost(), 255);
  803.             bGopher->StoreName(buf);          
  804.             fGolist->InsertBefore( aRow, (DObject*) bGopher);
  805.             fGoview->ChangeRowSize( aRow, 1); 
  806.             Dirty(); 
  807.             }
  808.         }
  809. }
  810.  
  811. void DGopherListDoc::EditOldGopher()
  812. {    
  813.     short aRow = fGoview->GetSelectedRow();
  814.     DGopher *aGopher= fGoview->SelectedGopher();
  815.     if (aGopher) {
  816.         char oldKind= aGopher->fType;
  817.         if (aGopher->Edit(true) ) {
  818.             if (aGopher->fType != oldKind) {
  819.               DGopher* bGopher=
  820.                    DGopherList::CopyToNewKind( aGopher->fType, aGopher, fGolist, true);
  821.               if (bGopher) {
  822.                     delete aGopher; //aGopher->suicide();  
  823.                     fGolist->AtPut( aRow, (DObject*) bGopher); //! re-insert bgopher into list 
  824.                     }
  825.                 }
  826.             Nlm_RecT vbounds;
  827.             fGoview->GetRowRect( aRow, vbounds);
  828.             fGoview->InvalRect( vbounds);
  829.             Dirty(); 
  830.             }
  831.         }
  832. }
  833.  
  834.  
  835. void DGopherListDoc::InsertNewGopher(Boolean editAll)
  836. {            
  837.     short aRow = fGoview->GetSelectedRow();
  838.     if (aRow==0) aRow= fGolist->GetSize();
  839.     aRow++;    // insert after...
  840.     
  841.     DGopher* aGopher= new DGopher(); 
  842.     char oldKind= aGopher->fType;    
  843.     aGopher->SetOwner(fGolist); 
  844.     if (!editAll) aGopher->fType= kTypeFolder; // !editAll is used for NewServer() call !
  845.      
  846.     if (aGopher->Edit( editAll)) {
  847.         //if (aGopher->fType != oldKind || !editAll) // bug here -- missing CopyToNewKind
  848.         {
  849.          DGopher* bGopher=
  850.               DGopherList::CopyToNewKind( aGopher->fType, aGopher, fGolist, true); 
  851.          if (bGopher) {
  852.                 delete aGopher; //aGopher->suicide();  
  853.                 aGopher= bGopher;
  854.                 }
  855.             }
  856.             
  857.         fGolist->InsertBefore( aRow, (DObject*) aGopher);
  858.         fGoview->ChangeRowSize( aRow, 1);  
  859.         Dirty(); // !? this needs to track the fGolist, which can be popped/pushed
  860.         }        
  861.     else
  862.         delete aGopher; //aGopher->suicide();   
  863. } 
  864.     
  865.  
  866. // static
  867. short DGopherListDoc::DefaultGopherView(DGopher* aGopher)
  868. {
  869.     Boolean canDisplay = false;
  870.     short bestItem = 0;
  871.     DGopherMap* aMapper;
  872.     
  873.     if (!aGopher) return 0;
  874.     
  875.             // ???
  876.     if (aGopher->fType == kTypeFolder 
  877.         || aGopher->fType == kTypeQuery
  878.         || aGopher->fIsMap ) 
  879.             return 0;
  880.             
  881.     gCursor->watch();
  882.     if (aGopher->fIsPlus == kGopherPlusYes && !aGopher->fViews) 
  883.         DGopherListDoc::ReadItemInfo(aGopher);
  884.     if (aGopher->fViews) {
  885.  
  886. #if 0
  887.         aGopher->CheckViewMappers();
  888.         // ?? now how do we get bestItem value ?? set aGopher->fViewChoice ??
  889.         
  890. #else
  891.         char *cp, *viewkind;
  892.         short i, nviews;
  893.         unsigned short lastrank, bestPref = 0;
  894.         
  895.         nviews= aGopher->fViews->GetSize();
  896.         for (i= 0; i<nviews; i++) {
  897.             lastrank = 0; 
  898.             DGopherItemView* giv= (DGopherItemView*) aGopher->fViews->At(i);
  899.             viewkind= (char*)giv->Kind();
  900.             aMapper= gGopherMap->MatchHandlerKind( lastrank, viewkind); 
  901.             if (aMapper) {
  902.                 if ( aMapper->GetDisplay() ) canDisplay= true;
  903.                 if ( aMapper->fPreference > bestPref) {
  904.                     bestItem= i + 1;
  905.                     bestPref= aMapper->fPreference;
  906.                     }
  907.                 }
  908.             }
  909. #endif
  910.  
  911.         }
  912.     else {
  913.         aMapper= gGopherMap->MatchGopherType( aGopher->fType, true); 
  914.         if (aMapper) {
  915.             if ( aMapper->GetDisplay() ) canDisplay= true;
  916.             //if (aMapper->fHandlerType == 1) canDisplay= true;
  917.             //else if (aMapper->fHandlerType == 2) canFile= true;
  918.             }
  919.         }
  920.         
  921.     //gCursor->arrow();
  922.     return bestItem;
  923. }
  924.  
  925.  
  926.  
  927.  
  928.  
  929.  
  930.  
  931.  
  932.  
  933.  
  934. class DGoviewListView;
  935.  
  936. class DViewChoiceDialog : public DWindow 
  937. {
  938. public:
  939.     enum ViewChoiceCmds { cFetchToDisplay = 111, cFetchToFile, cFetchInfo, 
  940.                                         cFetchGroup, cFetchEdit, cMapBut };
  941.     DGoviewListView*    fListBox;  //DListBox * fListBox;
  942.     short             fViewChoice, fFetchMethod;
  943.     DGopher  * fParentGo;
  944.     DCluster * fFetchCluster;
  945.     
  946.     DViewChoiceDialog(DGopher* itsGopher);
  947.     virtual void Open();
  948.     virtual void OkayAction();
  949.     virtual short Result() { return fViewChoice; }
  950.     virtual Boolean IsMyAction(DTaskMaster* action);
  951. };
  952.  
  953.  
  954. class DGoviewListView : public DTableView 
  955. {
  956. public:
  957.     DViewChoiceDialog *    fDialog;
  958.     DList * fItems; // of DGopherItemView*
  959.     DGopher * fGopher;
  960.     Nlm_FonT    fItalFont;
  961.     
  962.     DGoviewListView(long id, DGopher* itsGopher, DViewChoiceDialog* itsDialog, short pixwidth, short pixheight);
  963.     virtual void DoClickAt(short row, short col);
  964.     virtual void SingleClickAt(short row, short col);
  965.     virtual void DoubleClickAt(short row, short col);
  966.     virtual void GetReadyToShow();
  967.     virtual void DrawCell(Nlm_RecT r, short row, short col);
  968.     virtual DGopherItemView* SelectedView();
  969.     virtual void  SetValue( short value) { SelectCells( value, 0, false); }
  970.     virtual short GetValue() { 
  971.         if (GetSelectedRow() != kNoSelection) return (1+GetSelectedRow());
  972.         else return 0;
  973.       }
  974. };
  975.  
  976.  
  977. DGoviewListView::DGoviewListView(long id, DGopher* itsGopher, DViewChoiceDialog* itsDialog, 
  978.                                                 short pixwidth, short pixheight):
  979.     DTableView( id, itsDialog, pixwidth, pixheight, 5, 2, 50, 15, true, false),
  980.     fGopher( itsGopher), fItalFont(NULL),
  981.     fDialog(itsDialog)
  982. {    
  983.     fItems= fGopher->fViews;
  984.     this->SetSlateBorder(true); 
  985.     this->SetResize( DView::relsuper, DView::relsuper);
  986.     this->SetTableFont(gGoviewFont);
  987.     if (gGoviewFontName && *gGoviewFontName)
  988.         fItalFont= Nlm_GetFont( gGoviewFontName, gGoviewFontSize, false, true, false, NULL);
  989.     else
  990.         fItalFont= Nlm_GetFont( gTextFontName, gTextFontSize, false, true, false, NULL);
  991.     this->GetReadyToShow(); // ??
  992. }
  993.  
  994. void DGoviewListView::DoClickAt( short row, short col)
  995. {
  996.     DGopherItemView* giv= (DGopherItemView*) fItems->At(row);
  997.     if (giv) {
  998.         if (giv->fViewStatus  == DGopherItemView::kUnknownStatus) {
  999.             // dialog to append view handler
  1000.             if (DGopherMapDoc::EditHandler( (char*) giv->Kind())) {
  1001.                 fGopher->CheckViewMappers();
  1002.                 this->Invalidate();
  1003.                 }
  1004.             }
  1005.         else {
  1006.             DTaskMaster okay(cOKAY);
  1007.             fDialog->IsMyAction( &okay);
  1008.             //fDialog->OkayAction();
  1009.             //fDialog->Close();
  1010.             }
  1011.         }
  1012. }
  1013.  
  1014. void DGoviewListView::SingleClickAt( short row, short col)
  1015. {
  1016.     DTableView::SingleClickAt( row, col); // must select item !
  1017.     if (gSingleClicker) DoClickAt( row, col);
  1018. }
  1019.  
  1020. void DGoviewListView::DoubleClickAt( short row, short col)
  1021. {
  1022.     DTableView::DoubleClickAt( row, col); 
  1023.     if (gDoubleClicker) DoClickAt( row, col);
  1024. }
  1025.  
  1026.  
  1027. DGopherItemView* DGoviewListView::SelectedView()
  1028. {
  1029.     if (GetSelectedRow() != kNoSelection) 
  1030.         return (DGopherItemView*)fItems->At( GetSelectedRow());
  1031.     else 
  1032.         return NULL;
  1033. }
  1034.  
  1035. void DGoviewListView::GetReadyToShow()
  1036. {
  1037.     short  wid;
  1038.     SelectFont();
  1039.     short charheight= Nlm_FontHeight();
  1040.     if (fItems && fItems->GetSize() > 0) SetTableSize( fItems->GetSize(), GetMaxCols());
  1041.     SetItemHeight(0, GetMaxRows(), charheight);
  1042.     wid= Nlm_StringWidth("* ");
  1043.     this->SetItemWidth( 0, 1, wid);
  1044.     wid= Nlm_StringWidth("application/gopher+-menu-long");
  1045.     this->SetItemWidth( 1, 1, wid);  
  1046. }
  1047.  
  1048. void DGoviewListView::DrawCell(Nlm_RecT r, short row, short col)
  1049. {
  1050.     if (col) r.left += 2; // quick fix for cells against each
  1051.     DGopherItemView* giv= (DGopherItemView*) fItems->At(row);
  1052.     if (giv) {
  1053.         Boolean changefont= false;
  1054.         //if (giv->fViewStatus == DGopherItemView::kMaxStatus) 
  1055.         //    this->SetValue( row);          
  1056.         switch (col) {
  1057.             case 0:  
  1058.                 Nlm_DrawString(&r, (char*) giv->ViewStatus(), 'l', false);
  1059.                 break;   
  1060.             case 1: 
  1061.                 if (giv->fViewStatus==DGopherItemView::kUnknownStatus && fItalFont) {
  1062.                     changefont= true;
  1063.                      Nlm_SelectFont(fItalFont);
  1064.                      }
  1065.                 Nlm_DrawString(&r, (char*) giv->ViewVal(), 'l', false);
  1066.                 break;   
  1067.             }
  1068.         if (changefont) SelectFont();
  1069.         }
  1070. }
  1071.  
  1072.  
  1073.  
  1074.  
  1075.  
  1076.  
  1077.  
  1078.  
  1079. DViewChoiceDialog::DViewChoiceDialog(DGopher* itsGopher) :
  1080.         DWindow( 0, NULL, DWindow::fixed, -10, -10, -50, -20, "View choices", kDontFreeOnClose),
  1081.         fViewChoice(0),
  1082.         fFetchMethod(0),
  1083.         fParentGo(itsGopher),
  1084.         fListBox(NULL)
  1085. {    
  1086. }
  1087.  
  1088. Boolean DViewChoiceDialog::IsMyAction(DTaskMaster* action) 
  1089. {
  1090.       switch (action->Id()) {
  1091.  
  1092.         default:
  1093.             return DWindow::IsMyAction(action);    
  1094.             
  1095. #if 0            
  1096.             case cMapBut: {
  1097.                 short nviews= 0;
  1098.                 if (fParentGo && fParentGo->fViews) 
  1099.                     nviews= fParentGo->fViews->GetSize();
  1100.                 if (nviews) {        
  1101.                     long i;
  1102.                     char* cp;
  1103.                     for (i= 0; i<nviews; i++) {
  1104.                         char * viewkind;
  1105.                         unsigned short lastrank = 0; 
  1106.                         DGopherItemView* giv= (DGopherItemView*) fParentGo->fViews->At(i);
  1107.                         viewkind= (char*)giv->Kind();
  1108.                         DGopherMap* aMapper= gGopherMap->MatchHandlerKind( lastrank, viewkind); 
  1109.                         if (!aMapper) {
  1110.                             
  1111.                             }
  1112.                         }
  1113.                     }
  1114.                 }
  1115.                 return true;
  1116. #endif
  1117.  
  1118.         }
  1119. }
  1120.  
  1121.  
  1122. void DViewChoiceDialog::OkayAction() 
  1123. { 
  1124.     if (fListBox) fViewChoice= fListBox->GetValue(); /* - 1;  */
  1125.     else fViewChoice= 0;
  1126.     if (fFetchCluster) switch ( fFetchCluster->GetValue()) {
  1127.         default:
  1128.         case 1: fFetchMethod= cFetchToDisplay; break;
  1129.         case 2: fFetchMethod= cFetchToFile; break;
  1130.         case 3: fFetchMethod= cFetchInfo; break;
  1131.         case 4: fFetchMethod= cFetchEdit; break;
  1132.         }
  1133. }
  1134.  
  1135. void DViewChoiceDialog::Open()
  1136. {
  1137.     DCluster* clu;
  1138.     DRadioButton* rb;
  1139.     DView* super = this;
  1140.     DPrompt* pr;
  1141.     unsigned short lastrank, bestPref = 0;
  1142.     long  nviews = 0, bestItem = 0;
  1143.     long    macType, macSire;
  1144.     char * viewkind = NULL;
  1145.     DGopherMap* aMapper;
  1146.     Boolean canDisplay= false, canFile= true; // always?? even for folder?
  1147.     Boolean unmapped= false;
  1148.     char namebuf[256];
  1149.     
  1150.     sprintf( namebuf, "Fetching '%s'", (char*)fParentGo->ShortName());
  1151.     pr= new DPrompt(0, this, namebuf, 0, 0, Nlm_programFont);         
  1152.     this->NextSubviewBelowLeft();
  1153.     sprintf( namebuf,  "Mod-date: %s   Size: %s", (char*)fParentGo->GetDate(), (char*)fParentGo->GetDataSize());
  1154.     pr= new DPrompt(0, this, namebuf, 0, 0, Nlm_programFont);         
  1155.     this->NextSubviewBelowLeft();
  1156.     
  1157.     if (fParentGo && fParentGo->fViews) {
  1158.         fParentGo->CheckViewMappers();
  1159.         short height= 12 * Max( 3, Min( 7, fParentGo->fViews->GetSize()));
  1160.         fListBox= new DGoviewListView( 0, fParentGo, this, 250, height);
  1161.         fListBox->SetResize( DView::relsuper, DView::relsuper);
  1162.         fListBox->SetValue( fParentGo->fViewchoice - 1); 
  1163.         lastrank = 0; 
  1164.         aMapper= gGopherMap->MatchHandlerKind( lastrank, 
  1165.                                     (char*)fParentGo->GetViewChoiceKind()); 
  1166.         if (aMapper && aMapper->GetDisplay() ) canDisplay= true;
  1167.         
  1168.         this->NextSubviewBelowLeft();
  1169.         sprintf( namebuf, " ? is an unknown view, double-click to link to a handler"LINEEND" * indicates the best view");
  1170.         //new DPrompt(0, this, namebuf, 0, 0, gSmallFont);         
  1171.         new DNotePanel(0, this, namebuf, 250, 0, gSmallFont);
  1172.         //this->NextSubviewBelowLeft();
  1173.         }
  1174.      
  1175.     else {
  1176.         // no views
  1177.         fListBox= NULL;
  1178.         pr= new DPrompt(0, this, "No view data. Default view is selected.", 0, 0, Nlm_programFont);         
  1179.         aMapper= gGopherMap->MatchGopherType( fParentGo->fType, true); 
  1180.         if (aMapper && aMapper->GetDisplay() ) canDisplay= true;
  1181.         }
  1182.  
  1183.         
  1184.     clu= new DCluster(cFetchGroup, super, 15, 5, false, "Fetch options");
  1185.     fFetchCluster= clu;
  1186.     super= clu;
  1187.     rb= new DRadioButton( cFetchToDisplay, super, "to Display");
  1188.     if (!canDisplay) rb->Disable();
  1189.     else rb->SetStatus(true); // ?? or clu->SetValue(1); 
  1190.  
  1191.     super->NextSubviewToRight();
  1192.     rb= new DRadioButton( cFetchToFile, super, "to File");
  1193.     if (!canFile) rb->Disable();
  1194.     else if (!canDisplay) rb->SetStatus(true);
  1195.     
  1196.     super->NextSubviewToRight();
  1197.     rb= new DRadioButton( cFetchInfo, super, "Get Info");
  1198.  
  1199. #ifdef BYVIEW_EDIT
  1200.     super->NextSubviewToRight();
  1201.     rb= new DRadioButton( cFetchEdit, super, "Edit");
  1202. #endif
  1203.     super= this;
  1204.     
  1205.     //if (unmapped) DButton* but= new DButton( cMapBut, super, "Map unknown(?) types");
  1206.      
  1207.     this->AddOkayCancelButtons();    
  1208.     gCursor->arrow();
  1209.     DWindow::Open();
  1210. }
  1211.  
  1212.  
  1213.  
  1214.  
  1215.     
  1216. // static
  1217. Boolean DGopherListDoc::GopherByViewDialog(DGopher* go, DGopherList* itsList) 
  1218. {
  1219.     short iview= 0;
  1220.     Boolean result= false;
  1221.     if (go) { 
  1222.         if (go->fIsPlus == kGopherPlusYes && !go->fViews) 
  1223.             DGopherListDoc::ReadItemInfo(go);
  1224.         DViewChoiceDialog* dlg= new DViewChoiceDialog(go);
  1225.         if ( dlg->PoseModally() ) {
  1226.             iview = dlg->Result();
  1227.             Boolean oldsave= go->fSaveToDisk;
  1228.             switch (dlg->fFetchMethod) {
  1229.                 default:
  1230.                 case DViewChoiceDialog::cFetchToDisplay: go->fSaveToDisk= false; break;
  1231.                 case DViewChoiceDialog::cFetchToFile: go->fSaveToDisk= true; break;
  1232.                 case DViewChoiceDialog::cFetchInfo  : iview= DGopher::kGetItemInfo; break;
  1233.  
  1234. #ifdef BYVIEW_EDIT
  1235.                         // this is mainly for debugging golinkdocs ...
  1236.                 case DViewChoiceDialog::cFetchEdit  : 
  1237.                 {    
  1238.                 char oldKind= go->fType;
  1239.                 if (go->Edit(true) ) {
  1240.                     if (go->fType != oldKind) {
  1241.                             // ?? use go->fOwnerList instead of passing itsList ??
  1242.                       DGopher* bGopher= 
  1243.                           DGopherList::CopyToNewKind( go->fType, go, itsList, true);
  1244.                       if (bGopher) {
  1245.                             long aRow= itsList->GetIdentityItemNo((DObject*) go);        // uses long(item) == long(indexobj)
  1246.                             itsList->AtPut( aRow, (DObject*) bGopher); //! re-insert bgopher into list 
  1247.                             delete go; //go->suicide();  
  1248.                             }
  1249.                         }
  1250.                     }
  1251.                 delete dlg;
  1252.                 return true;
  1253.                 }
  1254.                 break;
  1255. #endif
  1256.  
  1257.                 }
  1258.             delete dlg;
  1259.             result= true;
  1260.             DGopherListDoc::ProcessGopher(go, iview);
  1261.             go->fSaveToDisk= oldsave;
  1262.             }
  1263.         else  
  1264.             delete dlg;
  1265.         }
  1266.     return result;
  1267. }
  1268.  
  1269.  
  1270. void DGopherListDoc::PinWindow(Boolean turnon)
  1271. { 
  1272.     fPinned= turnon;
  1273.     if (fStickpin) {
  1274.         if (fPinned) fStickpin->SetIcon( &gPushpinIn, true);
  1275.         else fStickpin->SetIcon( &gPushpinOut, true);
  1276.         }
  1277. }
  1278.  
  1279.  
  1280.  
  1281. Boolean DGopherListDoc::IsMyAction(DTaskMaster* action) 
  1282. {
  1283.     long  menuid;
  1284.     
  1285.     if (!action) return false;
  1286.     if (action->fSuperior && action->fSuperior->Id() == kViewKindMenu)
  1287.         menuid= action->fSuperior->Id();
  1288.     else 
  1289.         menuid= action->Id();
  1290.         
  1291.     switch (menuid) {
  1292.  
  1293.             case DApplication::kNew:
  1294.                 NewGopherDoc();
  1295.                 return true;
  1296.  
  1297.             case DApplication::kUndo:
  1298.                 Message(MSG_OK,"DGopherListDoc::Undo not ready.");
  1299.                 return true;
  1300.                 
  1301.             case DApplication::kCopy:
  1302.                 if (gClipGopher) gClipGopher->suicide();
  1303.                 gClipGopher= fGoview->SelectedGopher();
  1304.                 if (gClipGopher) {
  1305.                     gClipGopher= (DGopher*) gClipGopher->Clone();
  1306.                     gClipGopher->SetOwner(gClipGophers);
  1307.                     }
  1308.                 return true;
  1309.             
  1310.             case DApplication::kPaste:
  1311.                 AddGopherToView( gClipGopher);
  1312.                 return true;
  1313.  
  1314.             case DApplication::kCut:
  1315.                 CutClearSelection( true);
  1316.                 return true;
  1317.             case DApplication::kClear:
  1318.                 CutClearSelection( false);
  1319.                 return true;
  1320.             case DApplication::kSelectAll:
  1321.                 Message(MSG_OK,"DGopherListDoc::SelectAll not ready.");
  1322.                 return true;
  1323.             
  1324.             case cParentPopup:
  1325.                 {
  1326.                 DPopupList* pl= (DPopupList*) action;  
  1327.                 if (pl) PopData( pl->GetValue() - 1);                    
  1328.                 }
  1329.                 return true;
  1330.                 
  1331.             case cParentDrop:
  1332.                 //if (fParentPop) PopData( fParentPop->GetValue() - 1);        
  1333.                 Nlm_Beep();            
  1334.                 return true;
  1335.             
  1336.             case cPushpin:
  1337.                 PinWindow( !fPinned);
  1338.                 return true;
  1339.  
  1340.           case kViewChoiceMenu:
  1341.  
  1342. #ifndef BOBS_WIN_MAC                        
  1343.                 // we need a small dialog w/ our newest popup menu
  1344.                 (void) DGopherListDoc::GopherByViewDialog( this->fGoview->SelectedGopher(), fGolist);
  1345. #else
  1346.               {
  1347.                 short iview= action->Id() - kViewDefault;  
  1348.                 DGopher* go= this->fGoview->SelectedGopher();
  1349.                 if (go) DGopherListDoc::ProcessGopher(go, iview);
  1350.                 }
  1351. #endif
  1352.                 return true;
  1353.                 
  1354.             case kViewKindMenu:
  1355.                 switch(action->Id()) {
  1356.                     case kViewByDefault:
  1357.                             this->SortView(DGopherList::kSortByItem); return true;
  1358.                     case kViewByDate:
  1359.                             this->SortView(DGopherList::kSortByDate); return true;
  1360.                     case kViewBySize:
  1361.                             this->SortView(DGopherList::kSortBySize); return true;
  1362.                     case kViewByName:
  1363.                             this->SortView(DGopherList::kSortByName); return true;
  1364.                     case kViewByKind:
  1365.                             this->SortView(DGopherList::kSortByKind); return true;
  1366.                     case kViewByHost:
  1367.                             this->SortView(DGopherList::kSortByHost); return true;
  1368.                     case kViewAsText:
  1369.                     case kViewAsLink:
  1370.                             this->ToTextDoc( action->Id() == kViewAsLink); return true;
  1371.                     default: return false;
  1372.                     }
  1373.             
  1374.         default: 
  1375.             return false;
  1376.         }
  1377. }
  1378.             
  1379.  
  1380.  
  1381. Boolean DGopherListDoc::IsMyTask(DTask* theTask) 
  1382. {
  1383.     if (theTask->fKind == kGoListdoc) {
  1384.         ProcessTask( theTask);
  1385.         return true;
  1386.         }
  1387.     else 
  1388.         return DWindow::IsMyTask(theTask);
  1389. }
  1390.  
  1391. void DGopherListDoc::ProcessTask(DTask* theTask) 
  1392. {
  1393.     if (theTask->fNumber == cProcessGopher) {
  1394.         // ?? fix for obscure Motif bug from DGoAskDoc calling ProcessGopher...
  1395.         DGopher* aGoph= (DGopher*) theTask->fExtra;
  1396.         Boolean saveuse= this->fInUse;
  1397.         this->fInUse= true;
  1398.         DGopherListDoc::ProcessGopher( aGoph, aGoph->fViewchoice);
  1399.         this->fInUse= saveuse;
  1400.         //aGoph->suicide(); //??
  1401.         }
  1402.         
  1403.     else if (theTask->fNumber == cAdd && fParent) {
  1404.         fInUse= true;  
  1405.         fParent->ShowProgress();
  1406.         if (fParent->fInfoSize) {
  1407.         
  1408. #ifdef TRY_WITHOUT_THIS
  1409.             // this code, if it worked, would permit async display of gopher items
  1410.             // as each line/item is received.  but it is buggy, causing crashes
  1411.             // after a few fetches.  Rewrite at some point -- try Reverse StrStr(bufend,CRLF"+INFO")
  1412.             
  1413.             char * cbeg = fParent->fInfo;
  1414.             char * cend = cbeg + fParent->fInfoSize;
  1415.             char * cp = cend;
  1416.             char    clineend = '\012';  
  1417.                 
  1418.             if (StrStr( cbeg, CRLF"+INFO")) {
  1419.                 Boolean done = false;
  1420.                 do {
  1421.                     while (cp > cbeg && *cp != clineend) cp--; 
  1422.                     if (cp <= cbeg) done= true;
  1423.                     else if (StrNCmp( cp+1, "+INFO", 5) == 0) done= true;
  1424.                     else cp--;
  1425.                 } while (!done);
  1426.                 }
  1427.             else    // assume gopher- !? poor assumption?
  1428.                 while (cp > cbeg && *cp != clineend) cp--; 
  1429.             
  1430.             if (cp <= cbeg) cp= cend; 
  1431.             //char csave= *cp; *cp= 0;  // no more need for null term
  1432.             this->AddData(cbeg, cp - cbeg);  
  1433.             //*cp= csave;
  1434.             if (cp < cend) cp++; // skip the linefeed, which puts extra blank line in fDoc...
  1435.             
  1436.             long clen= cend - cp;
  1437.             cbeg= (char*) MemDup( cp, clen+1);
  1438.             //fParent->DeleteInfo();// this creates new fInfo
  1439.             if (fParent->fInfo) MemFree(fParent->fInfo); 
  1440.             fParent->fInfo= cbeg;   
  1441.             fParent->fInfoSize= clen; 
  1442.  
  1443.             if (fFirststuff>0) {
  1444.                 fGoview->SetColWidths(); //?!! required, some time after having real data
  1445.                 fFirststuff= 0;
  1446.                 }
  1447. #endif
  1448.  
  1449.             }
  1450.         
  1451.         if (fParent->ThreadProgress() == DGopher::kThreadDoneReading) {
  1452.             theTask->SetRepeat(false); // done w/ gopher fetch, dequeue this task
  1453.             this->ShowMessage("done reading");
  1454.             fInUse= false;  
  1455.             
  1456.                 // if TRY_WITHOUT_THIS is fixed, ?? change this
  1457.             char * cbeg = fParent->fInfo;
  1458.             char * cend = cbeg + fParent->fInfoSize;
  1459.             if (cend > cbeg) {
  1460.                 //*cend= 0; // no longer need null term
  1461.                 // ?? is bomb bug due to lack of end of data ??
  1462. #if 0
  1463.                 // still don't know where this bomb is coming from
  1464.                 // occurs ?? only when returning 1 gopher item in a gopherlist
  1465.                 // but beyond that ??? data looks okay, happens thru query item & thru go+ ask forms
  1466.                 
  1467.                 //char* kBombBugPatch = "i(Quick bug patch for obscure bomb)\t\tno.where.ever\t0"CRLF;    
  1468.                 
  1469.                 char *cp = cbeg;
  1470.                 for (short i= 0; i<2; i++) {
  1471.                     cp = StrChr(cp, kLF);
  1472.                     if (cp) cp++;
  1473.                     }
  1474.                 if (!cp) {
  1475.                     DGopher* ago= new DGopher();
  1476.                     ago->SetLink( *fParent->fInfo, fParent->fInfo);
  1477.                     char link1[512];
  1478.                     sprintf( link1, "%c%s\t%s\t%s\t%d\t%c",
  1479.                         ago->fType, (char*) ago->GetName(), (char*) ago->GetPath(), 
  1480.                         (char*) ago->GetHost(), ago->fPort, ' ');
  1481.                     delete ago;
  1482.                     
  1483.                     char *next= fParent->fInfo;
  1484.                     next= StrChr(next, kLF);
  1485.                     if (next) next++;
  1486.                     
  1487.                     char *tmp= StrDup(kBombBugPatch);
  1488.                 
  1489.                     StrExtendCat( &tmp, link1);
  1490.                     StrExtendCat( &tmp, next);
  1491.                     //StrExtendCat( &tmp, fInfo);
  1492.                     MemFree(fParent->fInfo);
  1493.                     fParent->fInfo= tmp;
  1494.                     fParent->fInfoSize= StrLen(tmp);
  1495.                     }
  1496. #endif
  1497.                     
  1498.                 this->AddData(cbeg, cend-cbeg);  
  1499.                      
  1500.                 if (fGolist->GetSize() < 1) { 
  1501.                     this->Close(); //this->suicide(); //delete this; 
  1502.                     return; 
  1503.                     }
  1504.                 else if (gFetchSingles && fGolist->GetSize() == 1) {
  1505.                     fGoview->OpenGopherLink(0);
  1506.                     this->Close(); // this works, but leaves un-updated window region on front window
  1507.                     return;
  1508.                     }
  1509.                     
  1510.                 fGoview->SetColWidths(); // !! required, some time after having real data
  1511.                 fGoview->Invalidate(); 
  1512.                 }
  1513.             else 
  1514.                 this->Close();  //this->suicide(); //delete this;  // dies here on mswin?
  1515.             }
  1516.         }
  1517.         
  1518.     else {
  1519.         DWindow::ProcessTask(theTask);
  1520.         }
  1521. }
  1522.  
  1523.  
  1524. void DGopherListDoc::Close()
  1525. {
  1526.     if (fParent &&  fParent->ThreadProgress() != DGopher::kThreadDoneReading) {
  1527.         // kill tcp connection !!!!!!!!
  1528.         fParent->CloseQuery();
  1529.         //fParent= NULL; // don't delete !?
  1530.         }
  1531.  
  1532.     if (!Nlm_EmptyRect(&fViewrect)) gGopherListDocRect= fViewrect;  
  1533.     if (gGopherDoc == this) gGopherDoc= NULL; // track front gopher doc/window
  1534.     fInUse= false;
  1535.     fPinned= false;
  1536.     DWindow::Close();
  1537. }
  1538.  
  1539. void DGopherListDoc::ResizeWin()
  1540. {
  1541.     DWindow::ResizeWin();
  1542.     if (fGoview && !Nlm_EmptyRect(&fViewrect)) gGopherListDocRect= fViewrect;  
  1543. }
  1544.  
  1545.  
  1546.  
  1547.  
  1548.  
  1549. void DGopherListDoc::MakeSubviews()
  1550. {
  1551.     if (!fGolist) fGolist= new DGopherList(fParent); //NULL
  1552.     fGolist->fDeleteObjects= DList::kDeleteObjects;
  1553.     if (!fGoview) {
  1554.         short width, height;
  1555.         Nlm_RecT        r;
  1556.         Nlm_PoinT        nps;
  1557.         this->GetNextPosition( &nps);
  1558.         nps.x= 0;  // where is that odd x-offset from ?
  1559.         this->SetNextPosition( nps);
  1560.         width = MAX( 40, gGopherListDocRect.right - gGopherListDocRect.left) 
  1561.                    - Nlm_vScrollBarWidth  - nps.x; 
  1562.         height= MAX( 60, gGopherListDocRect.bottom - gGopherListDocRect.top) 
  1563.                      - Nlm_hScrollBarHeight - nps.y;   
  1564. #ifdef WIN_MSWIN
  1565.         width  -= 16;
  1566.         height -= 24;
  1567. #endif
  1568.     
  1569.         fGoview= new DGolistView(0, this, fGolist, width, height);
  1570.         }
  1571.     else fGoview->fItems= fGolist;  
  1572. } 
  1573.  
  1574.  
  1575. Boolean DGopherListDoc::CanReadFrom(DFile*& aFile)
  1576. {
  1577.         // callers have already checked that aFile exists and IsGopherDoc !!
  1578.         // ?? don't need this part now ??
  1579.     if (!aFile) {
  1580.         char *data = (char*) gFileManager->GetInputFileName(".go4",NULL); 
  1581.         if (data) aFile= new DFile( data, "r");
  1582.         }
  1583.     if (aFile) return true;
  1584.     else return false;
  1585. }
  1586.  
  1587.  
  1588. Boolean DGopherListDoc::ReadFrom(DFile* aFile)
  1589. {
  1590.     if (aFile) {
  1591.         gCursor->watch();
  1592.         this->SetTitle( (char*)aFile->GetShortname() );
  1593.  
  1594.         MakeSubviews();
  1595.         if (!fParent) {
  1596.             char docurl[1024];
  1597.             StrCpy(docurl, "file:///");
  1598.             StrNCat(docurl, (char*)aFile->GetName(), 1000);
  1599.             docurl[1023]= 0;
  1600.             fParent= DGopherList::GopherFromURL(docurl, strlen(docurl), fGolist);
  1601.             // ! GopherFromURL() sticks new gopher into list also !
  1602.             fGolist->fParentMenu= fParent;
  1603.             }
  1604.         
  1605.         aFile->OpenFile();
  1606.         ulong filelen;
  1607.         aFile->GetDataLength(filelen);
  1608.         char* buf= (char*) MemNew( filelen+1);
  1609.         aFile->ReadData( buf, filelen);
  1610.         this->AddData( buf, filelen);
  1611.         MemFree( buf);
  1612.         aFile->CloseFile();
  1613.         delete aFile;
  1614.         
  1615.         if (fGolist->GetSize() < 1) { return false; }
  1616.         fGoview->SetColWidths();     //?
  1617.         //fGoview->Invalidate();      //?? for ReplaceData only ??
  1618.         gCursor->arrow();
  1619.         fInUse= false;  
  1620.         return true;
  1621.         }
  1622.     else
  1623.         return false;
  1624. }
  1625.  
  1626.  
  1627.  
  1628. Boolean DGopherListDoc::CanReadFrom( DGopher* itsParent)
  1629. {
  1630.     if (itsParent) {
  1631.         fParent= itsParent;
  1632.         //if (fParent->fThreadState == DGopher::kThreadNotStarted) 
  1633.             fParent->ReadTask();   
  1634.         if (fParent->fInfoSize<10 && fParent->fThreadState == DGopher::kThreadDoneReading) {
  1635.             fParent->fThreadState= DGopher::kThreadNotStarted; // ! need to reset this somewhere for used gophers
  1636.             return false; 
  1637.             }
  1638.         else
  1639.             return true; 
  1640.         }
  1641.     else
  1642.         return false;
  1643. }
  1644.  
  1645.  
  1646. Boolean DGopherListDoc::ReadFrom( DGopher* itsParent)
  1647. {
  1648.     if (itsParent) {
  1649.         fParent= itsParent;
  1650.         this->SetTitle( (char*)fParent->ShortName());
  1651.         MakeSubviews();
  1652.         if (fParent->fThreadState == DGopher::kThreadNotStarted) 
  1653.             fParent->ReadTask();   
  1654.         if (fParent->fInfoSize<10 && fParent->fThreadState == DGopher::kThreadDoneReading) { 
  1655.             //this->Close(); //suicide();
  1656.             fParent->fThreadState= DGopher::kThreadNotStarted; // ! need to reset this somewhere for used gophers
  1657.             return false; 
  1658.             }
  1659.      
  1660.         DTask* aTask= newTask(cAdd, kGoListdoc); 
  1661.         aTask->SetRepeat(true);
  1662.         this->PostTask( aTask); 
  1663.         this->ShowMessage("opening link...");
  1664.         fInUse= true;
  1665.         return true; 
  1666.         }
  1667.     else
  1668.         return false;
  1669. }
  1670.  
  1671.  
  1672. // static
  1673. void DGopherListDoc::NewGopherDoc()
  1674. {
  1675.     gCursor->watch();
  1676.     DGopherListDoc* win= new DGopherListDoc( DGopherListDoc::kGoListdoc);
  1677.     //win->Open( theGo); 
  1678.     if (win) { 
  1679.         char* buf="+INFO: 1IUBio-Archive\t\tiubio.bio.indiana.edu\t71\t+\n"
  1680.                 "+INFO: 1GopherPup home\t1/IUBio-Software+Data/util/gopher/gopherpup\tiubio.bio.indiana.edu\t70\t+\n"
  1681.                 "+INFO: 1University of Minnesota Mother Gopher\t\tgopher.micro.umn.edu\t70\t+\n";
  1682.         ulong buflen = StrLen(buf);
  1683.  
  1684.         win->SetTitle( "Untitled" );
  1685.         win->MakeSubviews();
  1686.         win->AddData( buf, buflen);
  1687.         win->fGoview->SetColWidths(); //?
  1688.         win->Open( true);
  1689.         gCursor->arrow();
  1690.         }
  1691. }
  1692.  
  1693.  
  1694.  
  1695. void DGopherListDoc::Open( DFile* aFile)
  1696. {
  1697.     if ( ReadFrom( aFile) )
  1698.         Open( true);
  1699.     else
  1700.         Close(); //suicide();
  1701. }
  1702.  
  1703. void DGopherListDoc::Open( DGopher* itsParent)
  1704. {
  1705.     if ( ReadFrom( itsParent) )
  1706.         Open( true);
  1707.     else
  1708.         Close(); 
  1709. }
  1710.  
  1711.  
  1712. void DGopherListDoc::Open( Boolean haveData)
  1713. {
  1714.     if (!haveData) {
  1715.         Close();
  1716.         return;
  1717.         }
  1718.  
  1719. #if 1                
  1720.     // short minwidth= Nlm_StringWidth( (char*)fParentGo->ShortName());
  1721.     this->Select(); // ?? for motif
  1722.     Nlm_ResizeWindow( (Nlm_GraphiC)fWindow, kWinDragHeight, kWinScrollWidth,
  1723.                          kWinMinWidth, kWinExtraHeight);
  1724. #endif
  1725.  
  1726.     fSaveHandler= this; // replace fGoview's handler w/ us
  1727.     if (fStatus && fGolist) fGolist->SetStatus( fStatus);
  1728.     if (fParentlist && fParentPop) {
  1729.         char * name;
  1730.         short i, n= fParentlist->GetSize();
  1731.         if (fParent) name= (char*)fParent->ShortName();
  1732.         else name= "Current link";
  1733.         fParentPop->AddItem(name);
  1734.         for (i= n-1; i>=0; i--) {
  1735.             DGopher* go= NULL;
  1736.             DGopherList* golist= (DGopherList*) fParentlist->At(i);
  1737.             if (golist) go= golist->fParentMenu;
  1738.             if (go) fParentPop->AddItem((char*)go->ShortName());   
  1739.             }
  1740.         }
  1741.  
  1742.     fGoview->Invalidate();         // force redraw !?
  1743.     fGoview->SetOffset(0, 0); //  zero the scrollbars
  1744.     fGoview->SetTop(0);                 //  reset data scroll offset 
  1745.  
  1746.     short i, n= fGolist->GetSize();
  1747.     for (i=0; i<n; i++) 
  1748.         fGoview->SetLineHeight( i, fGolist->GopherAt(i));
  1749.  
  1750.     gGopherDoc= this; // track front gopher doc/window
  1751.     fGoview->SizeToSuperview( this, true, true); //??
  1752.     DWindow::Open();
  1753. }
  1754.  
  1755.  
  1756. void DGopherListDoc::UpdateListSize()
  1757. {        
  1758.     short nnew, nold, i;
  1759.     
  1760.     nold= fGoview->GetMaxRows();  
  1761.     nnew= fGolist->GetSize();
  1762.     //fGoview->SetTableSize(nnew, 9);
  1763.     fGoview->ChangeRowSize( -1, nnew-nold); // was (nold, .. -1 prevents unneeded redraw ?
  1764. }
  1765.  
  1766. void DGopherListDoc::AddData(char* gopherData, long datalen)
  1767. {        
  1768.     short nnew, nold, i;
  1769.     
  1770.     nold= fGolist->GetSize();
  1771.     fGolist->ReadLinks(gopherData, datalen);
  1772.     nnew= fGolist->GetSize();
  1773.     //fGoview->SetTableSize(nnew, 9);
  1774.     fGoview->ChangeRowSize( -1, nnew-nold); // was (nold, .. -1 prevents unneeded redraw ?
  1775. }
  1776.  
  1777. void DGopherListDoc::Activate()
  1778. {    
  1779.     SetViewMenu(true); 
  1780.     if (gLockWinMenuItem)  gLockWinMenuItem->SetStatus( fInUse || fPinned);        
  1781.     gGopherDoc= this; // track front gopher doc/window
  1782.     DWindow::Activate();
  1783. }
  1784.  
  1785. void DGopherListDoc::Deactivate()
  1786. {    
  1787.     SetViewMenu(false); 
  1788.     if (gLockWinMenuItem)  gLockWinMenuItem->SetStatus(false);
  1789.     //if (gGopherDoc == this) gGopherDoc= NULL; 
  1790.     // ^^ can't do now, Ask window needs this, and when it comes out, this goes... 
  1791.     DWindow::Deactivate();
  1792. }
  1793.  
  1794. void DGopherListDoc::SetViewMenu(Boolean activate)
  1795. {         
  1796. #ifndef BOBS_WIN_MAC                        
  1797.   //gWindowManager->SetLastActive(this); // motif don't track active windows too good, needs help
  1798. #else                        
  1799.                         // THIS IS NO GOOD ON XWIN, and probably NO GOOD on MSWIN
  1800.                         // Vibrant currently has no way of removing single menu items
  1801.                         // except for Mac.  Only option for others seems to be removal
  1802.                         // of entire (sub) menu, with no way to replace w/ a new menu
  1803.                         // in *same* position !!!
  1804.    if (gViewChoiceMenu) {
  1805.          short item= kViewDefault;
  1806.          gViewChoiceMenu->Reset();  
  1807.          gViewChoiceMenu->AddItem( item, "default");
  1808.          DGopher* go= fGoview->SelectedGopher();
  1809.          if (activate && go && go->fViews) {
  1810.             long i, n= go->fViews->GetSize();
  1811.             for (i= 0; i<n; i++) {
  1812.                 char *cp, smenu[256];
  1813.                 item++;
  1814.                 DGopherItemView* giv= (DGopherItemView*) go->fViews->At(i);
  1815.                 StrNCpy(smenu, (char*) giv->ViewVal(), 255);
  1816.                 //cp= smenu; 
  1817.                 //while (cp= strchr(cp, '/')) *cp= '_';
  1818.                 gViewChoiceMenu->AddItem( item, smenu);
  1819.                 //gViewChoiceMenu->EnableItem( item); 
  1820.                 }
  1821.              }
  1822.      }
  1823. #endif
  1824. }
  1825.  
  1826.  
  1827. void DGopherListDoc::AddGopherToView( DGopher* aGopher)
  1828. {    
  1829.     if (aGopher) {
  1830.         short aRow = fGoview->GetSelectedRow();
  1831.         if (aRow==0) aRow= fGolist->GetSize();
  1832.         aRow++;    // insert after...
  1833.         aGopher= (DGopher*) aGopher->Clone(); 
  1834.         aGopher->SetOwner(fGolist); 
  1835.         fGolist->InsertBefore( aRow, (DObject*) aGopher);
  1836.         fGoview->ChangeRowSize( aRow, 1);  
  1837.         Dirty(); // !? this needs to track the fGolist, which can be popped/pushed
  1838.         }
  1839. }
  1840.  
  1841.  
  1842. void DGopherListDoc::CutClearSelection( Nlm_Boolean saveCut)
  1843. {    
  1844.     short aRow = fGoview->GetSelectedRow();
  1845.     if (aRow == DTableView::kNoSelection) return;
  1846.     DGopher* aGopher= fGolist->GopherAt(aRow);
  1847.     if (saveCut && aGopher) {
  1848.         if (gClipGopher) gClipGopher->suicide();
  1849.         gClipGopher= aGopher;
  1850.         gClipGopher= (DGopher*) gClipGopher->Clone();        
  1851.         gClipGopher->SetOwner(gClipGophers); 
  1852.         }
  1853.     fGolist->AtDelete( aRow); // this kills aRow gopher
  1854.     fGoview->SetEmptySelection(false);
  1855.     fGoview->ChangeRowSize( aRow, -1);  
  1856.     Dirty();  
  1857. }
  1858.  
  1859.  
  1860. void DGopherListDoc::WriteTo(DFile* aFile)
  1861. {
  1862.     char     line[512];
  1863.     char    *data;
  1864.     Boolean    callerOwnsFile= (aFile != NULL);
  1865.     
  1866.     if (!callerOwnsFile) {
  1867.         data= this->GetTitle();
  1868.         sprintf(line, "%s.go4", data);
  1869.         MemFree(data);
  1870.         data= (char*) gFileManager->GetOutputFileName(line);  
  1871.         if (data) aFile= new DFile( data, "w", "TEXT", "IGo4");
  1872.         }
  1873.         
  1874.     if (aFile) {
  1875.         gCursor->watch();
  1876.         data= fGolist->WriteLinks();
  1877.         ulong    dlen= StrLen(data);
  1878.         
  1879.         aFile->OpenFile();
  1880.         aFile->WriteData(data, dlen);
  1881.         aFile->CloseFile();
  1882.         MemFree(data);
  1883.         if (!callerOwnsFile) delete aFile; 
  1884.         this->NotDirty();
  1885.         gCursor->arrow();
  1886.         }    
  1887. }
  1888.  
  1889.  
  1890.  
  1891.  
  1892.  
  1893.  
  1894.  
  1895.  
  1896.  
  1897.  
  1898.  
  1899.  
  1900. //class DGolistView : public DTableView
  1901.  
  1902.     
  1903. DGolistView::DGolistView(long id, DView* itsSuperior, DGopherList* itsItems, 
  1904.     short pixwidth, short pixheight):
  1905.     DTableView( id, itsSuperior, pixwidth, pixheight, 0, 9, 50, 36),
  1906.     fItems(itsItems), fDragGopher(NULL), fDragging(false)
  1907. {    
  1908.     this->SetSlateBorder(false);
  1909.   this->SetResize( DView::relsuper, DView::relsuper);
  1910.  
  1911.     ////>>nevermore>>////this->SetColWidths(); // BAD call HERE ON PPC !!!
  1912.     if (gGoviewFont == NULL) gGoviewFont= Nlm_programFont;
  1913.     if (gTextFont == NULL) gTextFont= Nlm_programFont;
  1914.     this->SetTableFont(gGoviewFont);
  1915.     MakeSmallFont();
  1916. }
  1917.  
  1918.  
  1919. void DGolistView::SizeToSuperview( DView* super, Boolean horiz, Boolean vert)
  1920. {
  1921.         // size only lower and right sides == leave top area...
  1922. #if 0
  1923. #ifdef WIN_MOTIF
  1924.     //DTableView::SizeToSuperview( super, horiz, vert);
  1925. #if 0
  1926.     Nlm_RecT r, myr;
  1927.     super->ViewRect(r);
  1928.     GetPosition(myr);
  1929.     if (horiz) myr.right  = r.right - myr.left; // - r.left
  1930.     if (vert)  myr.bottom = r.bottom - myr.top; //- r.top 
  1931.     //this->Select(); // motif requires ?
  1932.     SetPosition( myr);
  1933. #endif
  1934. #else    
  1935.     Nlm_RecT r, myr;
  1936.     super->ViewRect(r);
  1937.     GetPosition(myr); // ViewRect(myr); <<!NO, diff from GetPos/SetPos
  1938.     if (horiz) myr.right= (r.right - r.left) +1;
  1939.     // myr.right -= (Nlm_vScrollBarWidth - 8); // mswin fix ?? 
  1940.     if (vert) myr.bottom =  (r.bottom - r.top)  +1; 
  1941.     // myr.bottom -= (Nlm_hScrollBarHeight + 10); // mswin fix ??
  1942.     SetPosition( myr);
  1943. #endif
  1944. #endif
  1945.     this->FindLocation(); //?? added 14Mar94, gopher tables were doing this
  1946. }
  1947.  
  1948. void DGolistView::Resize(DView* superview, Nlm_PoinT sizechange)
  1949. {
  1950.     DTableView::Resize( superview, sizechange);
  1951. }
  1952.  
  1953.  
  1954.  
  1955. void DGolistView::Hold(Nlm_PoinT mouse)
  1956. {
  1957.     DTableView::Hold(mouse);
  1958. }
  1959.  
  1960. //Local DGopher* gDragGopher = NULL;
  1961.  
  1962. void DGolistView::Drag(Nlm_PoinT mouse)
  1963. {
  1964.     short row, col;
  1965.     DTableView::Drag(mouse);
  1966.  
  1967.     // this is called on drag, if click/release are ignored
  1968.     //PointToCell(mouse, row, col);
  1969.     //fDragGopher= fItems->GopherAt(row);
  1970.     fDragging= true;
  1971.     gCursor->plus();
  1972. }
  1973.  
  1974. void DGolistView::Release(Nlm_PoinT mouse)
  1975. {
  1976.     DTableView::Release(mouse);
  1977.     gCursor->arrow();
  1978.     
  1979.     //short row, col;
  1980.     //PointToCell(mouse, row, col);
  1981.     //DGopher* ag= fItems->GopherAt(row);
  1982.     
  1983.     DWindow* win= gWindowManager->WhichWindow( mouse);
  1984.     if (fDragGopher && fDragging && win && win != this->GetWindow()) {
  1985.         if (win->Id() == DGoLinkedTextDoc::kGoLitextdoc) {
  1986.             ((DGoLinkedTextDoc*) win)->LinkToSelection( fDragGopher);
  1987.             Nlm_Beep();
  1988.             }
  1989.         else if (win->Id() == DGopherListDoc::kGoListdoc) {
  1990.             ((DGopherListDoc*) win)->AddGopherToView( fDragGopher);
  1991.             Nlm_Beep();
  1992.             }
  1993.         }
  1994.     fDragging= false;
  1995.     fDragGopher= NULL;
  1996. }
  1997.  
  1998.  
  1999. void DGolistView::OpenGopherLink(short gopherItem)
  2000. {
  2001.     DGopher* ag= fItems->GopherAt(gopherItem); 
  2002.     if (ag) {
  2003.         Boolean nooption= false;
  2004.         Boolean optionIsOn= gKeys->option();
  2005.         Boolean oneKnownView = (ag->fViews && ag->fViews->GetSize() < 2);
  2006.  
  2007.         if (oneKnownView) {
  2008.             unsigned short lastrank = 0;
  2009.             DGopherItemView* giv= (DGopherItemView*) ag->fViews->First();
  2010.             char * viewkind= (char*)giv->Kind();
  2011.             DGopherMap* aMapper= gGopherMap->MatchHandlerKind( lastrank, viewkind); 
  2012.             if (!aMapper) oneKnownView= false;
  2013.             }
  2014.             
  2015.         nooption= (ag->fType == kTypeFolder
  2016.             || ag->fType == kTypeQuery  // ???
  2017.           || ag->fIsPlus != kGopherPlusYes
  2018.           || oneKnownView 
  2019.           ); 
  2020.           
  2021.         if (!nooption && DGopherListDoc::gOptionIsOn) 
  2022.             optionIsOn= !optionIsOn;
  2023.                     
  2024.         ((DGopherListDoc*)fSuperior)->ShowMessage("opening link...");
  2025.         if (optionIsOn) 
  2026.             (void) DGopherListDoc::GopherByViewDialog(ag, ag->fOwnerList);
  2027.         else  {
  2028.             short itsViewchoice= DGopherListDoc::DefaultGopherView(ag);
  2029.             DGopherListDoc::ProcessGopher( ag, itsViewchoice);
  2030.             }
  2031.         }
  2032. }
  2033.  
  2034.  
  2035.  
  2036.  
  2037. void DGolistView::DoubleClickAt(short row, short col)
  2038. {
  2039.     if (gDoubleClicker) OpenGopherLink(row);
  2040. }
  2041.  
  2042. void DGolistView::SingleClickAt(short row, short col)
  2043. {
  2044.     DTableView::SingleClickAt(row,  col);
  2045.     ((DGopherListDoc*)fSuperior)->SetViewMenu();
  2046.     fDragGopher= fItems->GopherAt(row);
  2047.     gWindowManager->SetCurrent((DWindow*)fSuperior); // motif needs help
  2048.     if (gSingleClicker) OpenGopherLink(row);
  2049. }
  2050.  
  2051.  
  2052. DGopher* DGolistView::SelectedGopher()
  2053. {
  2054.     if (GetSelectedRow() != kNoSelection) 
  2055.         return fItems->GopherAt( GetSelectedRow());
  2056.     else 
  2057.         return NULL;
  2058. }
  2059.  
  2060.  
  2061. #define USE_MULTI_LINES 1
  2062.  
  2063. void DGolistView::SetLineHeight( short item, DGopher* theGo)
  2064. {
  2065. #if NOTNOW_USE_MULTI_LINES
  2066.   short icowidth;
  2067.   Nlm_SelectFont(fFont);
  2068.     switch (gIconSize) {
  2069.         case 0: icowidth= 14; break;
  2070.         case 1: icowidth= 20; break;
  2071.         default:
  2072.         case 2: icowidth= 36; break;
  2073.         }
  2074.     short nlines = 1;
  2075.     //if (gShowURL||gShowDate||gShowSize||gShowHost||gShowPort||gShowPath||gShowAdmin)
  2076.     if (gShowExtras)
  2077.         nlines++;
  2078.     short height= nlines * Nlm_LineHeight();
  2079.     if (theGo) height += theGo->HeightAbstract();
  2080.     height= MAX( icowidth, height);  // Nlm_FontHeight
  2081.     this->SetItemHeight( item, 1, height);
  2082. #endif
  2083. }
  2084.  
  2085.  
  2086.  
  2087. void DGolistView::SetColWidths()
  2088. {
  2089.     enum { kPlusWidth = 0, kTitleWidth = 1200 }; // == 10
  2090.     
  2091.     short icowidth, height, nlines, wid;
  2092.  
  2093.     nlines = 1;
  2094.     //if (gShowURL||gShowDate||gShowSize||gShowHost||gShowPort||gShowPath||gShowAdmin)
  2095.     if (gShowExtras)
  2096.         nlines++;
  2097.         
  2098.     //Nlm_WindoW w= Nlm_SavePort( GetNlmObject());
  2099.     SelectFont();
  2100.  
  2101.     if (fItems && fItems->GetSize() > 0) 
  2102.         this->SetTableSize( fItems->GetSize(), 3);  // was 9 cols
  2103.     
  2104.     switch (gIconSize) {
  2105.         case 0: icowidth= 14; break;
  2106.         case 1: icowidth= 20; break;
  2107.         default:
  2108.         case 2: icowidth= 36; break;
  2109.         }
  2110.         
  2111.     height= nlines * Nlm_LineHeight();  // Nlm_FontHeight
  2112. #if USE_MULTI_LINES
  2113.     if (fItems) {
  2114.         short i, n = fItems->GetSize();
  2115.         for (i= 0; i<n; i++) {
  2116.             DGopher* go= fItems->GopherAt(i);
  2117.             this->SetItemHeight( i, 1, MAX( icowidth, height + go->HeightAbstract()));
  2118.             }
  2119.         }
  2120.     else
  2121. #endif
  2122.         this->SetItemHeight( 0, GetMaxRows(), MAX( icowidth, height));
  2123.         
  2124.     this->SetItemWidth( 0, 1, icowidth+2);         
  2125.     this->SetItemWidth( 1, 1, kPlusWidth);  
  2126.     //wid= Nlm_StringWidth("A long title to measure for max width");
  2127.     this->SetItemWidth( 2, 1, kTitleWidth); 
  2128. }
  2129.  
  2130.  
  2131. void DGolistView::DrawCell(Nlm_RecT r, short row, short col)
  2132. {
  2133. #define gShowPlus  1
  2134.     // need a DTableView field to handle cell rect insets !
  2135.     //if (col) 
  2136.     r.left += 2; // quick fix for cells against each
  2137.     DGopher* ag= fItems->GopherAt(row); 
  2138.     if (ag) switch (col) {
  2139.     
  2140.         case 0: 
  2141.             ag->DrawIcon(r, gIconSize); 
  2142.             break;   
  2143.  
  2144. #if 0        
  2145.         case 1: { 
  2146.             Nlm_RecT     lr;
  2147.             lr= r;
  2148.             lr.bottom= lr.top + Nlm_LineHeight();
  2149.             ag->DrawPlus( lr); 
  2150.             } 
  2151.             break;
  2152. #endif
  2153.         
  2154.         case 2:  {
  2155.             Nlm_RecT     lr;
  2156.             Nlm_PoinT pt;
  2157.             short lineheight, absHeight = 0, nlines = 1;
  2158.             
  2159. #if 1
  2160.             lineheight= Nlm_LineHeight(); // store this const somewhere !?
  2161. #else
  2162.             //if (gShowURL||gShowDate||gShowSize||gShowHost||gShowPort||gShowPath||gShowAdmin)
  2163.             if (gShowExtras)    nlines++;
  2164.             if (ag->fAbstract) absHeight= ag->HeightAbstract(); // this can drag on draw time !!
  2165.             lineheight=  (r.bottom - r.top - absHeight) / nlines;
  2166. #endif
  2167.  
  2168.             lr= r;
  2169.             lr.bottom= lr.top + lineheight;
  2170.             ag->DrawTitle(lr); 
  2171.             
  2172.             if (ag->fType != kTypeNote && gShowExtras) {
  2173.               //(gShowURL||gShowDate||gShowSize||gShowHost||gShowPort||gShowPath||gShowAdmin)) 
  2174.               
  2175.                 lr.top = lr.bottom; 
  2176.                 lr.bottom= lr.top + lineheight;
  2177.                 Nlm_MoveTo(lr.left, lr.top);
  2178.               Nlm_SelectFont(gSmallFont); // this is a HACK !!
  2179.                 if (gShowDate) { ag->DrawDate(lr); Nlm_GetPen(&pt); lr.left = pt.x + 5;  } 
  2180.                 if (gShowSize) { ag->DrawSize(lr); Nlm_GetPen(&pt); lr.left = pt.x + 5;  } 
  2181.                 if (gShowHost) { ag->DrawHost(lr); Nlm_GetPen(&pt); lr.left = pt.x + 5;  } 
  2182.                 if (gShowPort) { ag->DrawPort(lr); Nlm_GetPen(&pt); lr.left = pt.x + 5;  } 
  2183.                 if (gShowPath) { ag->DrawPath(lr); Nlm_GetPen(&pt); lr.left = pt.x + 5;  } 
  2184.                 if (gShowURL)  { ag->DrawURL(lr); Nlm_GetPen(&pt); lr.left = pt.x + 5;  } 
  2185.                 if (gShowAdmin) { ag->DrawAdmin(lr); Nlm_GetPen(&pt); lr.left = pt.x + 5;  } 
  2186.                 if (gShowPlus) { ag->DrawPlus(lr); Nlm_GetPen(&pt); lr.left = pt.x + 5;  } 
  2187.                 }
  2188.             
  2189. #if USE_MULTI_LINES
  2190.             if (gShowAbstract && ag->fAbstract) {
  2191.                 lr.left= r.left;
  2192.                 lr.top = lr.bottom; 
  2193.                 lr.bottom= r.bottom; //lr.top + absHeight; 
  2194.                 Nlm_MoveTo(lr.left, lr.top);
  2195.                 ag->DrawAbstract( lr);
  2196.                 }
  2197. #endif
  2198.  
  2199.             SelectFont(); // double HACK !!
  2200.             }
  2201.             break;
  2202.  
  2203.         }
  2204. }
  2205.  
  2206.  
  2207.  
  2208.  
  2209. #if 0
  2210.                 ////////// old view
  2211.  
  2212. void DGolistView::SetColWidths()
  2213. {
  2214.     short icowidth, height, wid;
  2215.  
  2216.     //Nlm_WindoW w= Nlm_SavePort( GetNlmObject());
  2217.   Nlm_SelectFont(fFont);
  2218.  
  2219.     if (fItems && fItems->GetSize() > 0) 
  2220.         this->SetTableSize( fItems->GetSize(), 9);
  2221.     
  2222.     switch (gIconSize) {
  2223.         case 0: icowidth= 14; break;
  2224.         case 1: icowidth= 20; break;
  2225.         default:
  2226.         case 2: icowidth= 36; break;
  2227.         }
  2228.     height= icowidth; //Max( icowidth, Nlm_LineHeight());  // Nlm_FontHeight
  2229.     this->SetItemHeight( 0, fMaxRows, height);
  2230.  
  2231.     this->SetItemWidth( 0, 1, icowidth);     // go->WidthIcon(size)
  2232.     this->SetItemWidth( 1, 1, 10);     // go->WidthPlus()
  2233.     wid= Nlm_StringWidth("A long title to measure for max width");
  2234.     this->SetItemWidth( 2, 1, wid); // go->WidthTitle()
  2235.     
  2236.     wid= (gShowDate) ? Nlm_StringWidth(" 30Jan94 ") : 0;
  2237.     this->SetItemWidth( 3, 1, wid);      
  2238.     wid= (gShowSize) ? Nlm_StringWidth(" 1234kb ") : 0;
  2239.     this->SetItemWidth( 4, 1, wid);      
  2240.     wid= (gShowHost) ? Nlm_StringWidth(" gopher.some.where.edu ") : 0;
  2241.     this->SetItemWidth( 5, 1, wid);  
  2242.     wid= (gShowPort) ? 30 : 0;
  2243.     this->SetItemWidth( 6, 1, 30);          
  2244.     wid= (gShowPath) ? Nlm_StringWidth(" /some/path/to/timbuktu ") : 0;;
  2245.     this->SetItemWidth( 7, 1, wid);      
  2246.     wid= (gShowAdmin) ? Nlm_StringWidth(" gtirebiter@some.fancy.mailhost ") : 0;
  2247.     this->SetItemWidth( 8, 1, wid);  
  2248.     //Nlm_RestorePort( w); // bombing here w/ GetSize()==1 ???
  2249. }
  2250.  
  2251.  
  2252. void DGolistView::DrawCell(Nlm_RecT r, short row, short col)
  2253. {
  2254.     // need a DTableView field to handle cell rect insets !
  2255.             
  2256.     if (col) r.left += 2; // quick fix for cells against each
  2257.     DGopher* ag= fItems->GopherAt(row); 
  2258.     if (ag) switch (col) {
  2259.         case 0: ag->DrawIcon(r, gIconSize); break;   
  2260.         case 1: ag->DrawPlus(r); break;
  2261.         
  2262.         case 2: ag->DrawTitle(r); break;
  2263.         
  2264.         case 3: ag->DrawDate(r); break;
  2265.         case 4: ag->DrawSize(r); break;
  2266.         case 5: ag->DrawHost(r); break;
  2267.         case 6: ag->DrawPort(r); break;
  2268.         case 7: ag->DrawPath(r); break;
  2269.         case 8: ag->DrawAdmin(r); break;
  2270.         //case 9: ag->DrawKind(r); break;
  2271.         }
  2272. }
  2273.     //////////////// old view
  2274. #endif 
  2275.  
  2276.